Test for Job （动态规划 + 拓扑排序）

Test for Job
Time Limit : 10000/5000ms (Java/Other)   Memory Limit : 131072/65536K (Java/Other)
Total Submission(s) : 23   Accepted Submission(s) : 7
  
  

   
   Problem Description
  
  
  
  

   
   
Mr.Dog was fired by his company. In order to support his family, he must find a new job as soon as possible. Nowadays, It's hard to have a job, since there are swelling numbers of the unemployed. So some companies often use hard tests for their recruitment.
   
   
The test is like this: starting from a source-city, you may pass through some directed roads to reach another city. Each time you reach a city, you can earn some profit or pay some fee, Let this process continue until you reach a target-city. The boss will compute the expense you spent for your trip and the profit you have just obtained. Finally, he will decide whether you can be hired.
   
   
In order to get the job, Mr.Dog managed to obtain the knowledge of the net profit Vi of all cities he may reach (a negative Vi indicates that money is spent rather than gained) and the connection between cities. A city with no roads leading to it is a source-city and a city with no roads leading to other cities is a target-city. The mission of Mr.Dog is to start from a source-city and choose a route leading to a target-city through which he can get the maximum profit.
  
  
  
  

   
    
  
  

  
  

   
   Input
  
  
  
  

   
   The input file includes several test cases. 
The first line of each test case contains 2 integers 
   
   n and 
   
   m(1 ≤ 
   
   n ≤ 100000, 0 ≤ 
   
   m ≤ 1000000) indicating the number of cities and roads. 
The next 
   
   n lines each contain a single integer. The 
   
   ith line describes the net profit of the city 
   
   i, 
   
   Vi (0 ≤ |
   
   Vi| ≤ 20000) 
The next m lines each contain two integers 
   
   x, 
   
   y indicating that there is a road leads from city 
   
   x to city 
   
   y. It is guaranteed that each road appears exactly once, and there is no way to return to a previous city. 

  
  
  
  

   
    
  
  

  
  

   
   Output
  
  
  
  

   
   The output file contains one line for each test cases, in which contains an integer indicating the maximum profit Dog is able to obtain (or the minimum expenditure to spend)
  
  
  
  

   
    
  
  

  
  

   
   Sample Input
  
  
 
 

  
  
    
    

     
     6 5
1
2
2
3
3
4
1 2
1 3
2 4
3 4
5 6

    
    

   
   


   
   

    
    
 
   
   



   
   

    
    
Sample Output
   
   

   
   


    
    
     
     

      
      7
     
     

   
   

   
   

    
    
 
   
   

   
   

    
    


   
   
思路：此题一看就知道是求最长路径。用什么呢？（有负边，是用bellman-ford算法，写出来会超时，数据太大）

我们来考虑下，有u->v,s->v的路径，要求到v的最大路径，可以用u来更新和s来更新，只有u , s都被访问过之后才是v的最长路径，此时v的人度为0。u ,s 的人度为0，所以u , s 的最大路径，就是它本身。换句话说人度为0则最长路确定，这你应该想到怎么做了吧，对，拓扑排序。
一：求出拓扑序列。
二：递推求最长路。

代码如下：

#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>
using namespace std;
const int INF = -0X7fffffff;
int vist[100010];
int inde[100010];
int outde[100010];
int dist[100010];
int res[100010];
int order[100010];
int n , m ;
vector<int>g[100010];
void init()
{
    for(int i = 0; i <= n; i ++)
    {
        vist[i] = 0;
        inde[i] = 0;
        outde[i] = 0;
        g[i].clear();
        res[i] = INF;
    }
}
int main()
{
    while(scanf("%d%d",&n,&m)!= EOF)
    {
        init();
        int x , y ;
        for(int i = 1; i <= n; i ++)
        {
            scanf("%d",&dist[i]);
        }
        for(int i = 0; i < m; i++)
        {
            scanf("%d%d",&x, &y);
            g[x].push_back(y);
            inde[y] ++;
            outde[x] ++;
        }
        for(int i = 1; i <= n; i ++)
            if(inde[i] == 0) res[i] = dist[i];
        queue<int>q ;
        int cnt = 0;
        for(int i = 1; i <= n; i ++)
        {
            if(inde[i] == 0)
            {
                res[i] = dist[i];
                q.push(i);
            }
        }
        int u ;
        while(!q.empty())
        {
            u = q.front();
            q.pop();
            order[cnt ++] = u ;
            for(int i = 0; i < (int)g[u].size(); i ++)
            {
                if(--inde[g[u][i]] == 0)
                {
                    q.push(g[u][i]);
                }
            }
        }

        for(int i = 0; i < n; i ++)
        {
            for(int j = 0; j < (int)g[order[i]].size(); j ++)
            {
                res[g[order[i]][j]] = max(res[g[order[i]][j]] , res[order[i]] + dist[g[order[i]][j]]);
            }
        }
        int maxp = INF ;
        for(int i = 1; i <= n ; i ++)
            if(outde[i] == 0)
        {
            maxp = max(maxp , res[i]);
        }
        printf("%d\n",maxp);
    }
    return 0 ;
}